home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / Q-R / RIFF File Format / RIFFbyteio.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-07-29  |  4.2 KB  |  214 lines  |  [TEXT/KAHL]
  1. /*
  2. MOD 07-12-87 MAZ - byte i/o routines, generalized a little bit for converter
  3. */
  4. #include <FileMgr.h>
  5. #include "MAZlib.h"
  6.  
  7. /* for putbytes/getbytes */
  8. long buffersize = 0L;
  9. unsigned char *rblock = null;
  10. unsigned char *rbptr;
  11. long bbleft;
  12. long fbleft;
  13. long bufpos;
  14.  
  15. /* init for I/O - allocates buffer */
  16. bool init_io(pad)
  17. long pad;
  18.     {
  19.     unsigned char *padding;
  20.     
  21.     if (buffersize <= 0L)
  22.         {
  23.         /* free any old buffer */
  24.         if (rblock != null)
  25.             {
  26.             DisposPtr(rblock);
  27.             rblock = null;
  28.             }
  29.         /* do padding */
  30.         padding = null;
  31.         if (pad > 0L)
  32.             {
  33.             padding = (unsigned char *)NewPtr(pad);
  34.             if (padding == null)
  35.                 return(false);
  36.             }
  37.         /* pad < 0 means use -pad as buffersize */
  38.         if (pad < 0L)
  39.             buffersize = -pad;
  40.         else
  41.             buffersize = 0x10000L;
  42.         /* loop trying smaller sizes until we allocate a buffer */
  43.         while (buffersize >= 0L)
  44.             {
  45.             /* try the allocate at this size */
  46.              rblock = (unsigned char *)NewPtr(buffersize);
  47.              if (rblock != null)
  48.                  break;
  49.              /* failure: reduce size of buffer and try again */
  50.              buffersize -= 0x400L;
  51.              }
  52.          /* free any padding */
  53.          if (padding != null)
  54.              DisposPtr(padding);
  55.          }
  56.     /* return true if we got a buffer */
  57.     return(buffersize > 0L);
  58.     }
  59.  
  60. /* terminate I/O */
  61. term_io()
  62.     {
  63.     if (rblock != null)
  64.         {
  65.         DisposPtr(rblock);
  66.         rblock = null;
  67.         buffersize = 0L;
  68.         }
  69.     }
  70.  
  71. /* initialize for putbytes disk output */
  72. init_write(io)
  73. ioParam *io;
  74.     {
  75.     /* position to start of output, init an empty buffer */
  76.     rbptr = rblock;
  77.     bbleft = buffersize;
  78.     io->ioPosMode = fsFromStart;
  79.     io->ioPosOffset = 0L;
  80.     }
  81.  
  82. /* flush the output buffer */
  83. flushbytes(io)
  84. ioParam *io;
  85.     {
  86.     if (rbptr == rblock)
  87.         return;
  88.     io->ioReqCount = rbptr - rblock;
  89.     io->ioBuffer = (char *)rblock;
  90.     PBWrite(io, false);
  91.     rbptr = rblock;
  92.     bbleft = buffersize;
  93.     }
  94.  
  95. /* read initial buffer for getbytes */
  96. long init_read(io, pos)
  97. ioParam *io;
  98. long pos;
  99.     {
  100.     long filebytes;
  101.  
  102.     /* get the end of file position for file */
  103.     io->ioMisc = 0;
  104.     PBGetEOF(io, false);
  105.     filebytes = (long)io->ioMisc;
  106.     /* load the initial buffer from file */
  107.     io->ioReqCount = buffersize;
  108.     io->ioBuffer = (char *)rblock;
  109.     io->ioPosMode = fsFromStart;
  110.     io->ioPosOffset = bufpos = pos;
  111.     PBRead(io, false);
  112.     /* setup I/O variables */
  113.     rbptr = rblock;
  114.     bbleft = io->ioActCount;
  115.     fbleft = filebytes - pos;
  116.     /* return total size of file */
  117.     return(filebytes);
  118.     }
  119.  
  120. /* position the input file */
  121. pos_read(io, pos)
  122. ioParam *io;
  123. register long pos;
  124.     {
  125.     register long count;
  126.     
  127.     /* back up to start of this buffer */
  128.     count = rbptr - rblock;
  129.     fbleft += count;
  130.     bbleft += count;
  131.     rbptr = rblock;
  132.     /* see if this pos is within the current buffer */
  133.     if (pos < bufpos || pos >= bufpos + bbleft)
  134.         init_read(pos);        /* no, read in a new buffer */
  135.     else
  136.         {
  137.         /* position buffer to right place */
  138.         count = pos - bufpos;
  139.         fbleft -= count;
  140.         bbleft -= count;
  141.         rbptr += count;
  142.         }
  143.     }
  144.  
  145. /* read bytes from the input file */
  146. short getbytes(io, buffer, count)
  147. ioParam *io;
  148. register unsigned char *buffer;
  149. register long count;
  150.     {
  151.     /* check for eof easy way */
  152.     if (fbleft <= 0L)
  153.         return(1); /* my eof */
  154.     /* read any whole buffer-fulls needed */
  155.     while (bbleft <= count)
  156.         {
  157.         /* copy rest of current buffer (if any) */
  158.         if (bbleft > 0L)
  159.             {
  160.             fbleft -= bbleft;
  161.             count -= bbleft;
  162.             longcpybuf(buffer, rbptr, bbleft);
  163.             buffer += bbleft;
  164.             }
  165.         /* read in the next buffer */
  166.         bufpos = io->ioPosOffset;
  167.         io->ioReqCount = buffersize;
  168.         io->ioBuffer = (char *)rblock;
  169.         PBRead(io, false);
  170.         /* reset pointers */
  171.         rbptr = rblock;
  172.         bbleft = io->ioActCount;
  173.         if (bbleft <= 0L)
  174.             return(1);                /* eof */
  175.         }
  176.     /* transfer what's left */
  177.     if (count > 0)
  178.         {
  179.         longcpybuf(buffer, rbptr, count);
  180.         fbleft -= count;
  181.         bbleft -= count;
  182.         rbptr += count;
  183.         }
  184.     return(0);
  185.     }
  186.  
  187. /* write bytes to the output file */
  188. putbytes(io, buffer,count)
  189. ioParam *io;
  190. register unsigned char *buffer;
  191. register long count;
  192.     {
  193.     /* write any whole buffer-fulls needed */
  194.     while (bbleft <= count)
  195.         {
  196.         count -= bbleft;
  197.         longcpybuf(rbptr, buffer, bbleft);
  198.         buffer += bbleft;
  199.         io->ioPosMode = fsFromStart;
  200.         io->ioReqCount = buffersize;
  201.         io->ioBuffer = (char *)rblock;
  202.         PBWrite(io, false);
  203.         rbptr = rblock;
  204.         bbleft = buffersize;
  205.         }
  206.     /* write what's left */
  207.     if (count > 0)
  208.         {
  209.         longcpybuf(rbptr, buffer, count);
  210.         bbleft -= count;
  211.         rbptr += count;
  212.         }
  213.     }
  214.